const si = require('systeminformation');
const os = require('os');
/**
 * 获取系统性能指标
 * @returns {Promise<Object>} 包含各项系统指标的对象
 */
async function getSystemMetrics() {
    try {
        // 并行获取所有指标（比串行快3-5倍）
        const [
            cpuLoad,
            cpuInfo,
            memInfo,
            diskInfo,
            networkInfo,
            processes,
            uptime,
            temperature,
            currentTime
        ] = await Promise.all([
            si.currentLoad(),
            si.cpu(),
            si.mem(),
            si.fsSize(),
            si.networkStats(),
            si.processes(),
            si.time(),
            si.cpuTemperature().catch(() => ({ main: null })),
            new Date().toISOString()
        ]);

        // 计算关键指标
        const totalMemoryGB = (memInfo.total / 1024 / 1024 / 1024).toFixed(2);
        const usedMemoryGB = ((memInfo.total - memInfo.available) / 1024 / 1024 / 1024).toFixed(2);
        const memoryUsagePercent = ((memInfo.active / memInfo.total) * 100).toFixed(1);

        // 获取最耗资源的5个进程
        const topProcesses = processes.list
            .sort((a, b) => b.cpu - a.cpu)
            .slice(0, 5)
            .map(p => ({
                pid: p.pid,
                name: p.name,
                cpu: p.cpu.toFixed(1),
                mem: p.mem.toFixed(1),
                command: p.command
            }));

        // 获取Node进程内存使用
        const nodeProcess = processes.list.find(p => p.name.includes('node')) || {};
        const nodeMemoryUsage = (nodeProcess.mem || 0).toFixed(1);

        return {
            // === 基础系统信息 ===
            timestamp: currentTime, // ISO格式的当前时间，用于标记数据采集时间点
            hostname: os.hostname(), // 服务器主机名（如：server-01）
            uptime: uptime.uptime, // 系统连续运行时间（单位：秒）
            osType: `${os.type()} ${os.release()}`, // 操作系统类型和内核版本（如：Linux 5.4.0-80-generic）

            // === CPU 核心指标 ===
            cpu: {
                manufacturer: cpuInfo.manufacturer, // CPU制造商（如：Intel/AMD）
                brand: cpuInfo.brand,              // CPU具体型号（如：Xeon E5-2678）
                cores: cpuInfo.cores,             // 物理核心数（如：8核）
                speed: cpuInfo.speed,             // 当前运行频率（单位：GHz，如：2.5）
                load: cpuLoad.currentLoad.toFixed(1),       // 当前总负载百分比（如：24.5%）
                loadUser: cpuLoad.currentLoadUser.toFixed(1),   // 用户空间程序导致的负载
                loadSystem: cpuLoad.currentLoadSystem.toFixed(1), // 系统内核导致的负载
                temperature: temperature.main ? `${temperature.main}°C` : 'N/A' // 核心温度（可能不可用）
            },

            // === 内存使用情况 ===
            memory: {
                totalGB: totalMemoryGB,          // 物理内存总量（单位：GB，如：15.68）
                usedGB: usedMemoryGB,           // 已使用内存（含缓存，单位：GB）
                freeGB: (memInfo.available / 1024 / 1024 / 1024).toFixed(2), // 真正可用内存（单位：GB）
                usagePercent: memoryUsagePercent, // 内存使用率计算公式：(active / total) * 100
                nodeProcessUsage: nodeMemoryUsage // Node.js进程独占内存百分比（如：3.2%）
            },

            // === 磁盘存储信息 ===
            disks: diskInfo.map(disk => ({
                fs: disk.fs,                     // 文件系统标识（如：/dev/sda1）
                type: disk.type,                 // 文件系统类型（如：ext4/ntfs）
                sizeGB: (disk.size / 1024 / 1024 / 1024).toFixed(2), // 磁盘总容量（GB）
                usedGB: (disk.used / 1024 / 1024 / 1024).toFixed(2), // 已用空间（GB）
                usePercent: disk.use.toFixed(1)  // 使用率百分比（如：60.5%）
            })), // 注：多个磁盘会返回数组

            // === 网络状态 ===
            network: {
                rxSec: (networkInfo[0]?.rx_sec / 1024).toFixed(2) || 0, // 每秒接收数据量（单位：KB）
                txSec: (networkInfo[0]?.tx_sec / 1024).toFixed(2) || 0, // 每秒发送数据量（单位：KB）
                interfaces: Object.entries(os.networkInterfaces()).map(([name, data]) => ({
                    name,                         // 网卡名称（如：eth0）
                    ip4: data.find(i => i.family === 'IPv4')?.address, // IPv4地址
                    ip6: data.find(i => i.family === 'IPv6')?.address  // IPv6地址（可能不存在）
                }))
            },

            // === 进程监控 ===
            processes: {
                total: processes.all,           // 系统总进程数
                running: processes.running,     // 运行状态进程数
                blocked: processes.blocked,     // 阻塞状态进程数
                sleeping: processes.sleeping,    // 休眠状态进程数
                topProcesses:                   // 按CPU使用率排序的前5个进程
                    topProcesses.map(p => ({
                        pid: p.pid,                 // 进程ID
                        name: p.name,               // 进程名称（如：node）
                        cpu: p.cpu,                 // CPU占用百分比（如：15.5%）
                        mem: p.mem,                 // 内存占用百分比（如：2.8%）
                        command: p.command          // 启动命令（如：/usr/bin/node server.js）
                    }))
            },

            // === Node.js运行时信息 ===
            nodeVersion: process.version,    // Node.js版本（如：v18.12.1）
            pid: process.pid,                // 当前Node进程的PID
            platform: process.platform       // 运行平台（如：linux/win32/darwin）
        };
    } catch (error) {
        console.error('获取系统指标失败:', error);
        return {
            error: '无法获取系统指标',
            details: error.message
        };
    }
}

module.exports = getSystemMetrics;